home *** CD-ROM | disk | FTP | other *** search
/ Gekkan Dennou Club 147 / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan).7z / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan) (Track 1).bin / fdimg / —‹Œêsrc.lzh / disp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-18  |  21.8 KB  |  1,050 lines
  1. #include    "3DDEF.H"
  2. #include    "GLOBAL.H"
  3. #include    "FORWARD.H"
  4. #include    "XCODE.H"
  5. #include    "doslib.h"
  6.  
  7. /* 画面制御 */
  8.  
  9. /* チェックして、必要ならば画面にエコーする */
  10. /* 行の文字列が変更を受けたのでアップデートするのだ */
  11. void
  12. disp_check_1line_echo(register UNIT *tp)
  13. {
  14.     register short int i;
  15.     register UNIT **s,*p;
  16.  
  17.     for(s=SCREEN,i=0;i<YWIDTH-1;s++,i++) {
  18.         if ((p = *s) == tp) {
  19.             disp_1line(i,tp);
  20.         }
  21.     }
  22. }
  23.  
  24. /* チェックして、必要ならば画面にエコーする */
  25. /* 挿入である */
  26. void
  27. disp_check_1line_insert(UNIT *line,register UNIT *tp)
  28. {
  29.     register short int i;
  30.     register UNIT **s,*p;
  31.  
  32.     for(s=SCREEN,i=0;i<YWIDTH;s++,i++) {
  33.         if (*s == tp) {
  34. /*            *s = line;*/
  35.             disp_1line(i,line);
  36.  
  37.             while(s[1] != NOT) {    /* 下の行が、空行もしくは何かある */
  38.                 i++;
  39.                 if ((p = (*s++)->ATO) == NIL) break;
  40.                         /* 空行ならもう終わり */
  41.                 disp_1line(i,p);
  42. /*                *s = p;*/
  43.             }
  44.         }
  45.     }
  46. }
  47.  
  48. static UBYTE disp_work[VERY_LONG_LINE];
  49.  
  50. /* １行だけ y の位置に表示する */
  51. /* y は絶対座標である */
  52. void
  53. disp_1line(int y, UNIT *unit_pointer)
  54. {
  55.     int x;
  56.  
  57.     if (unit_pointer) {
  58.         line_get_body(disp_work,unit_pointer);
  59.         etc_bit_convert_and_disp(0,y,disp_work);
  60.     } else {
  61.         etc_bit_convert_and_disp(0,y,"");
  62.     }
  63.     SCREEN[y] = unit_pointer;            /* スクリーン更新 */
  64. }
  65.  
  66. /* １行だけカレントウインドウの y（相対） の位置に表示する */
  67. void
  68. disp_1line_rel(int y, UNIT *unit_pointer)
  69. {
  70.     disp_1line(CWY0+y,unit_pointer);
  71. }
  72.  
  73. UBYTE BOTTOM_FORMAT0[] = "===== ThunderWord V1.24 \
  74. ========================================================================";
  75. UBYTE BOTTOM_FORMAT1[] = "----- ThunderWord V1.24 \
  76. ------------------------------------------------------------------------";
  77.  
  78. /*
  79. ================================================================================================
  80. =***= ThunderWord V0.4 ==[全角:ひら:ROMA:無変]== 0123456789abcdefgh.zzz =========================
  81. ^    ^    ^    ^    ^    ^    ^    ^    ^    ^    ^    ^    
  82. 0    8    16    24    32    40    48    56    64    72    80    88
  83.             =[半角:カタ:通常:変換]=
  84. */
  85.  
  86. /* カレントテキストに changed mark を付ける */
  87. /* カレントテキストを表示しているすべてのウインドウに対して行う */
  88. void
  89. disp_btm_changed_10()
  90. {
  91.     disp_cursor_off();
  92.     if (CURRENT_CHANGED) {
  93.         disp_btm_changed_x(CURRENT_TEXT);
  94.     } else {
  95.         disp_btm_changed_erase_x(CURRENT_TEXT);
  96.     }
  97. }
  98.  
  99. /* カレントテキストに changed mark を付ける */
  100. /* カレントテキストを表示しているすべてのウインドウに対して行う */
  101. void
  102. disp_btm_changed()
  103. {
  104.     disp_cursor_off();
  105.     if (!CURRENT_CHANGED) {
  106.         disp_btm_changed_x(CURRENT_TEXT);
  107.         CURRENT_CHANGED = 1;
  108.     }
  109. }
  110.  
  111. /* テキストに bak mode を表示する */
  112. /* テキストを表示しているすべてのウインドウに対して行う */
  113. void
  114. disp_btm_bak_10_x(int tn)
  115. {
  116.     disp_cursor_off();
  117.     if (TDATA[tn].BAK_FLAG) {
  118.         disp_btm_changed_x_sub(tn,3,'B');
  119.     } else {
  120.         disp_btm_changed_x_sub(tn,3,'\0');
  121.     }
  122. }
  123.  
  124. /* テキストに changed mark を付ける */
  125. /* テキストを表示しているすべてのウインドウに対して行う */
  126. void
  127. disp_btm_changed_10_x(int tn)
  128. {
  129.     disp_cursor_off();
  130.     if (TDATA[tn].CHANGED_FLAG) {
  131.         disp_btm_changed_x(tn);
  132.     } else {
  133.         disp_btm_changed_erase_x(tn);
  134.     }
  135. }
  136.  
  137. /* 指定されたテキストに changed mark を付ける */
  138. /* そのテキストを表示しているすべてのウインドウに対して行う */
  139. void
  140. disp_btm_changed_x(int tn)
  141. {
  142.     disp_btm_changed_x_sub(tn,1,'*');
  143. }
  144.  
  145. void
  146. disp_btm_changed_x_sub(int tn,int x,UBYTE c)
  147. {
  148.     register int i;
  149.     UBYTE wlist[MAX_WINDOW];    /* フラグ用 */
  150.  
  151.     window_which_has_text_number(tn,wlist);
  152.  
  153.     disp_cursor_off();
  154.     etc_color(MIZU_EMPH_REV);
  155.     for(i = 0;i < MAX_WINDOW;i++) {
  156.         if (wlist[i]) {    /* そのテキストが割り当てられているウインドウである */
  157.             window_abs_loc(x,WDATA[i].WY1+1);
  158.             if (c) {
  159.                 B_PUTC(c);
  160.             } else if (i == CWN) {
  161.                 B_PUTC('=');
  162.             } else {
  163.                 B_PUTC('-');
  164.             }
  165.         }
  166.     }
  167.     etc_color(NORMAL);
  168. }
  169.  
  170. /* カレントから changed mark を外す */
  171. /* カレントテキストを表示しているすべてのウインドウに対して行う */
  172. void
  173. disp_btm_changed_erase_x(int tn)
  174. {
  175.     disp_btm_changed_x_sub(tn,1,'\0');
  176. }
  177.  
  178. /* 指定されたウインドウの、BOTTOM を表示する */
  179.  
  180. void
  181. disp_btm_line(int wn)
  182. {
  183.     UBYTE work[MAXLINE];
  184.     UBYTE work2[MAXLINE];
  185.     UBYTE w[5];
  186.     int i,x;
  187.  
  188.     /* 元をコピー */
  189.     if (wn == CWN) {
  190.         strcpy(work,BOTTOM_FORMAT0);
  191.     } else {
  192.         strcpy(work,BOTTOM_FORMAT1);
  193.     }
  194.  
  195.     if (i = strlen(FILE_NAMES_ST[WDATA[wn].WTEXTS].CONTENT)) {
  196. /*    if (i = strlen(FILE_NAMES[WDATA[wn].WTEXTS].CONTENT)) {*/
  197.         int j;
  198.         strncpy(&work[49],FILE_NAMES_ST[WDATA[wn].WTEXTS].CONTENT,i);
  199.         work[48] = ' ';
  200.         if (i+49 < XWIDTH) {
  201.             work[49+i] = ' ';
  202.             strcpy(&work2[1],FILE_NAMES[WDATA[wn].WTEXTS].CONTENT);
  203. /*            etc_get_pathname(&work2[1],FILE_NAMES[WDATA[wn].WTEXTS].CONTENT);*/
  204.             if (work2[1]) {
  205.                 *work2 = ' ';
  206.                 strcat(work2," ");
  207.             } else {
  208.                 *work2 = EOS;
  209.             }
  210.         } else {
  211.             *work2 = EOS;
  212.         }
  213.         j = strlen(work2);
  214.         if (j > XWIDTH-(49+i+3)+1) {    /* 長過ぎるのでカット */
  215.             j = XWIDTH-(49+i+3)-1;
  216.             work[XWIDTH-1] = '$';
  217.         } else {
  218.             strncpy(&work[49+i+3],work2,j);
  219.         }
  220.         work[XWIDTH] = EOS;
  221.     } else {
  222.         return;
  223.     }
  224.  
  225.     if (WDATA[wn].WY1+2 == UNDER_Y) {
  226.         strncpy(&work[25],"[    :    :    :    ]",46-25);
  227. /*        strncpy(&work[25],"[全角:カタ:かな:変換]",46-25);*/
  228. /*        strncpy(&work[25],"[半角:----:----:無変]",46-25);*/
  229.         for(i = 0,x = 26;x <= 41;i++,x += 5) {
  230.             if (FP_MODE[i] == (UBYTE)"ZKRM"[i]) {
  231.                 strncpy(&work[x],&("全角かなROMA無変"[i*4]),4);
  232.             } else {
  233.                 strncpy(&work[x],&("半角--------変換"[i*4]),4);
  234.             }
  235.         }
  236.     }
  237.     etc_color(MIZU_EMPH_REV);
  238.     disp_btm_line0(wn,work);
  239.     disp_btm_changed_10_x(WDATA[wn].WTEXTS);
  240.     disp_btm_bak_10_x(WDATA[wn].WTEXTS);
  241.     etc_color(NORMAL);
  242. }
  243.  
  244. /* 指定されたウインドウの、BOTTOM の位置に文字列を表示する */
  245. void
  246. disp_btm_line0(int wn, STR s)
  247. {
  248.     disp_cursor_off();
  249.     window_abs_loc(0,WDATA[wn].WY1+1);
  250.     B_PRINT(s);
  251.     SCREEN[WDATA[wn].WY1+1] = NOT;        /* -1 */
  252.     fep_follow_led();
  253. }
  254.  
  255. void
  256. disp_show_cursor()
  257. {
  258.     B_BPOKE(0x991,0);    /* OFF フラグをセット */
  259.     B_WPOKE(0x9bc,1);    /* ダウンカウンタを１に */
  260. }
  261.  
  262. void
  263. disp_cursor_off()
  264. {
  265.     B_CUROFF();
  266. }
  267.  
  268. void
  269. disp_cursor_on()
  270. {
  271.     B_CURON();
  272. }
  273.  
  274. /* CL がウインドウの中心－１行に来るように書き直す */
  275. void
  276. disp_cl_center_1()
  277. {
  278.     disp_cl_y((CWY1-CWY0)/2-1);
  279. }
  280.  
  281. /* CL がウインドウの中心に来るように書き直す */
  282. void
  283. disp_cl_center()
  284. {
  285.     disp_cl_y((CWY1-CWY0)/2);
  286. }
  287.  
  288. /* CL がウインドウの y 行目に来るように書き直す */
  289. void
  290. disp_cl_y(int y)
  291. {
  292.     int movel;
  293.  
  294.     disp_top_flush(line_trace(CL,-y,&movel));
  295.     CY = -movel;
  296. }
  297.  
  298. /* 指定された行を最上行として画面を書き直す */
  299. void
  300. disp_top_flush(UNIT *top)
  301. {
  302.     disp_middle_flush(0,top);
  303. }
  304.  
  305. /* 指定された行を i 行として以下の画面を書き直す */
  306. void
  307. disp_middle_flush(int t,UNIT *top)
  308. {
  309.     int i;
  310.  
  311.     for(i = 0;i < t;i++);
  312.     for(;i <= CWY1 - CWY0;i++) {
  313.         disp_1line_rel(i,top);
  314.         if (top) {
  315.             if (top == TAIL) {
  316.                 top = NIL;
  317.             } else {
  318.                 top = top->ATO;
  319.             }
  320.         }
  321.     }
  322. }
  323.  
  324. /* 前を後で置き換える */
  325. void
  326. disp_replace(UNIT *d,UNIT *s)
  327. {
  328.     register int i;
  329.     register UNIT **sc;
  330.  
  331.     for(sc=SCREEN,i=0;i<YWIDTH;sc++,i++) {
  332.         if (*sc == d) {
  333.             disp_1line(i,s);
  334.         }
  335.     }
  336. }
  337.  
  338. /* SCREEN[] で、前を後で置き換える */
  339. void
  340. disp_replace_SCREEN(UNIT *d,UNIT *s)
  341. {
  342.     register int i;
  343.     register UNIT **sc;
  344.  
  345.     for(sc=SCREEN,i=0;i<YWIDTH;sc++,i++) {
  346.         if (*sc == d) {
  347.             *sc = s;
  348.         }
  349.     }
  350. }
  351.  
  352. /* up0 を見付たら、次の行を up で書き換え、さらにボトムに当たるまで書き直す */
  353. void
  354. disp_replace_after(UNIT *up0, UNIT *up)
  355. {
  356.     register int i;
  357.     register UNIT **sc,*wp;
  358.  
  359.     for(sc=SCREEN,i=0;i<YWIDTH;) {
  360.         if (sc[i] == up0) {
  361.             i++;
  362.             wp = up;
  363.             while(sc[i] != NOT) {
  364.                 disp_1line(i++,wp);
  365.                 if ((wp == TAIL) && (sc[i] != NOT)){
  366.                     disp_1line(i,NIL);
  367.                     break;
  368.                 }
  369.                 wp = wp->ATO;
  370.             }
  371.         } else {
  372.             i++;
  373.         }
  374.     }
  375. }
  376.  
  377. /* SCREN に up0 を見付たら、次の行を up で書き換え、さらにボトムに当たるまで書き直す */
  378. void
  379. disp_replace_after_SCREEN(UNIT *up0, UNIT *up)
  380. {
  381.     register int i;
  382.     register UNIT **sc,*wp;
  383.  
  384.     for(sc=SCREEN,i=0;i<YWIDTH;) {
  385.         if (sc[i] == up0) {
  386.             i++;
  387.             wp = up;
  388.             while(sc[i] != NOT) {
  389.                 sc[i++] = wp;
  390.                 if ((wp == TAIL) && (sc[i] != NOT)){
  391.                     sc[i] = NIL;
  392.                     break;
  393.                 }
  394.                 wp = wp->ATO;
  395.             }
  396.         } else {
  397.             i++;
  398.         }
  399.     }
  400. }
  401.  
  402. /* 指定されたウィンドウを、top を最上行として書き直す */
  403. void
  404. disp_window_top_flush(int wn,UNIT *top)
  405. {
  406.     int i;
  407.  
  408.     for(i = WDATA[wn].WY0;i <= WDATA[wn].WY1;i++) {
  409.         disp_1line(i,top);
  410.         if (top) {
  411.             if (top == TAIL) {
  412.                 top = NIL;
  413.             } else {
  414.                 top = top->ATO;
  415.             }
  416.         }
  417.     }
  418.     disp_btm_line(wn);
  419. }
  420.  
  421. /* すべてのウインドウを描き直す。ただし、ボトムはいじらない */
  422. void
  423. disp_all_window_redraw()
  424. {
  425.     register int i;
  426.     register UNIT *p;
  427.  
  428.     for(i=0;i<YWIDTH-1;i++) {
  429.         if ((p = SCREEN[i]) != NOT) {
  430.             disp_1line(i,p);
  431.         }
  432.     }
  433.     work_cursor_cpx();
  434. }
  435.  
  436. /* １行だけ y の位置に表示する */
  437. /* y は絶対座標である */
  438. void
  439. disp_1line_rel_trans0(int x,int y, STR string)
  440. {
  441.     etc_bit_convert_and_disp(x,CWY0+y,string);
  442. }
  443.  
  444. /* 指定された位置から文字列を表示する */
  445. /* y は絶対座標である */
  446. /* 新しい X 座標を返す */
  447. int
  448. disp_half_line(int x,int y,STR s)
  449. {
  450.     return(etc_bit_convert_and_disp(x,y,s));
  451. }
  452.  
  453. /* カレントウインドウの y（相対） の位置に半行表示する */
  454. /* 新しい X 座標を返す */
  455. int
  456. disp_half_line_rel(int x,int y, STR s)
  457. {
  458.     return(disp_half_line(x,CWY0+y,s));
  459. }
  460.  
  461. /* 指定された行を y 座標として、それ以降の画面を書き直す */
  462. /* ちゃんとエコーする */
  463. void
  464. disp_half_flush(UNIT *top,int y)
  465. {
  466.     register int i;
  467.     register int delta = CWY1-CWY0;
  468.  
  469.     for(i = y;i <= delta;i++) {
  470.         disp_1line_rel(i,top);
  471.         if (top) {
  472.             if (top == TAIL) {
  473.                 top = NIL;
  474.             } else {
  475.                 top = top->ATO;
  476.             }
  477.         }
  478.     }
  479. }
  480.  
  481. extern UBYTE koho_10[10+1][MAXLINE];
  482. extern UWORD koho_10x[10+1];
  483.  
  484. /* 候補ブロック（ <= ９）を表示する */
  485. int
  486. disp_koho_block(int kn)
  487. {
  488.     register int i;
  489.     int x;
  490.  
  491.     window_abs_loc(0,UNDER_Y+1);
  492.     B_PRINT("\x1b[0K");            /* カーソルから右をクリア */
  493.     x = 0;
  494.     for(i=1;i<=9;i++) {
  495.         if (*koho_10[i]) {        /* 候補があるなら */
  496.             koho_10x[i] = x;
  497.             disp_koho(i,kn,&x,koho_10[i]);
  498.         } else {
  499.             break;
  500.         }
  501.     }
  502. }
  503.  
  504. /* 最下行に候補を表示する */
  505. /* x を更新する */
  506. /* 表示しきれない時は非零を返す */
  507. int
  508. disp_koho(int n,int kn,int *x,STR koho)
  509. {
  510.     UBYTE koho_d[MAXLINE];
  511.  
  512.     window_abs_loc(*x,UNDER_Y+1);
  513.     B_PUTC(n+'0');
  514.     B_PUTC('.');
  515.     if (n == kn) {
  516.         etc_color(10);    /* 選択色 */
  517.     }
  518.     etc_string_esc_cnv(koho,koho_d);
  519.     B_PRINT(koho_d);
  520.     *x = (B_LOCATE(-1,0) >> 16) + 1;
  521.     if (n = kn) {
  522.         etc_color(NORMAL);    /* 戻す */
  523.     }
  524.     return(*x > 80);
  525. }
  526.  
  527. void
  528. disp_cr_mode()
  529. {
  530.     if (CR_VIEW) {
  531.         KAIGYOU_CODE = KAIGYOU0;
  532.         KAIGYOU_HIGH = 0x81;
  533.         KAIGYOU_LOW = 0xde;
  534.     } else {
  535.         KAIGYOU_CODE = L'　';
  536.         KAIGYOU_HIGH = KAIGYOU_CODE >> 8;
  537.         KAIGYOU_LOW = KAIGYOU_CODE & 0xff;
  538.     }
  539. }
  540.  
  541. /* 変えたら非零を返す */
  542. int
  543. disp_tab_change(int a)
  544. {
  545.     if ((a <= 0) || (a > TAB_LENGTH_LIMIT) || (a > CURRENT_JIZUME)) {
  546.         /* 何もしない */
  547.     } else {
  548.         UNIT *wp;
  549.         int bp,y;
  550.  
  551.         etc_set_tab(a);
  552.         line_seigyou();
  553.         under_print((STR)"タブ変更：作業中・・・");
  554.         mark_set_mark(XCODE_SYSMARK - XCODE_MARK + CWN);    /* システムマーク */
  555.         wp = HEAD->ATO;    /* 先頭行 */
  556.         line_arrange_all(wp);
  557.         wp = mark_get_mark(XCODE_SYSMARK - XCODE_MARK + CWN,&bp);
  558.         mark_erase_mark(XCODE_SYSMARK - XCODE_MARK + CWN);    /* システムマークを消す */
  559.         CL = wp;
  560.         line_cl_cl();
  561.         disp_cl_y(CY);
  562.         work_line_analyze();
  563.         CPX = work_byte_to_CPX(bp);
  564.         CX0 = CX = ANALYZE[CPX].XPOS;
  565.         under_blanc();
  566.         return(1);
  567.     }
  568.     return(0);
  569. }
  570.  
  571. /* １行スクロールアップする */
  572. /* 最後に転送したポインタを返す */
  573. /* はみ出したなら */
  574. UNIT *
  575. disp_scroll_up1()
  576. {
  577.     register int lyw_total,yw;
  578.     register int cwy0,cwy1;
  579.     UNIT *last;
  580.     register int i,j;
  581.  
  582.     lyw_total = LYW_TOTAL/4;
  583.     cwy0 = CWY0;
  584.     last = SCREEN[cwy1 = CWY1];
  585.     if (yw = lyw_total*(cwy1-cwy0)) {    /* スクロールするラスタユニット数 */
  586.         TXRASCPY((cwy0+1)*lyw_total*256+cwy0*lyw_total,yw,0x0003);
  587.         for(i=cwy0,j=cwy0+1;j<=cwy1;i++,j++) {
  588.             SCREEN[i] = SCREEN[j];
  589.         }
  590.         SCREEN[cwy1] = NIL;
  591.     }
  592.     return(last);
  593. }
  594.  
  595. /* １行スクロールダウンする */
  596. /* 最後に転送したポインタを返す */
  597. UNIT *
  598. disp_scroll_dn1()
  599. {
  600.     register int lyw_total,yw;
  601.     register int cwy0,cwy1;
  602.     UNIT *last;
  603.     register int i,j;
  604.  
  605.     lyw_total = LYW_TOTAL/4;
  606.     last = SCREEN[cwy0 = CWY0];
  607.     cwy1 = CWY1;
  608.     if (yw = lyw_total*(cwy1-cwy0)) {    /* スクロールするラスタユニット数 */
  609.         TXRASCPY((cwy1*lyw_total-1)*256+(cwy1+1)*lyw_total-1,yw,0x8003);
  610.         for(i=cwy1,j=cwy1-1;j>=cwy0;i--,j--) {
  611.             SCREEN[i] = SCREEN[j];
  612.         }
  613.         SCREEN[cwy0] = NIL;
  614.     }
  615.     return(last);
  616. }
  617.  
  618. void
  619. disp_hmode()
  620. {
  621.     register int i;
  622.  
  623.     for(i=0;i<MAX_WINDOW;i++) {
  624.         if (WDATA[i].WY1+2 == UNDER_Y) {
  625.             break;
  626.         }
  627.     }
  628.     disp_btm_line(i);
  629. }
  630.  
  631. /* 最下行に記号候補を表示する */
  632. /* １６個ずつかく */
  633. void
  634. disp_kigou_koho()
  635. {
  636.     int xn;
  637.     UBYTE w[MAXLINE];
  638.     int kigou_block;
  639.     register int i;
  640.     UBYTE spacer[4];
  641.  
  642.     sprintf((char *)w,"[記号入力] <%4X>",kigou_begin);
  643.     window_abs_loc(0,UNDER_Y+1);
  644.     etc_color(MIZU_REV);
  645.     B_PRINT(w);
  646.     window_abs_loc(17,UNDER_Y+1);
  647.     kigou_block = kigou_begin & 0xfff0;
  648.     xn = kigou_begin & 0x000f;
  649.     if (etc_char_disp_len(etc_normal_jis(kigou_begin)) == 1) {
  650.         strcpy(spacer,"   ");
  651.     } else {
  652.         strcpy(spacer,"  ");
  653.     }
  654.     for(i = 0;i<16;i++) {
  655.         etc_color(RAW0);
  656.         B_PRINT(spacer);
  657.         if (i == xn) {
  658.             etc_color(MIZU_REV);
  659.         }
  660.         B_PUTC(etc_normal_jis(kigou_block+i));
  661.     }
  662.     etc_color(NORMAL);
  663.     B_PRINT("\x1b[0K");
  664. }
  665.  
  666. /* 指定位置から文字列 string を表示する */
  667. /* 左側には fl がある */
  668. /* 画面外に出そうになったら、スクロールアップし、その行数を返す */
  669. /* CWY1-CWY0 が最下行 */
  670. int
  671. disp_out_stop(STR fl,int *bx,int *by,STR string)
  672. {
  673.     UBYTE l[VERY_LONG_LINE*4], s[VERY_LONG_LINE*4];
  674.     register int fl_len;
  675.     register int flag;
  676.     register int ly = CWY1-CWY0;
  677.     register int scroll_up_counter = 0;
  678.  
  679.     if (!*string) {
  680.         return(0);
  681.     }
  682.     fl_len = strlen(fl);    /* 左側の長さを調べる */
  683.     cut_2line_link_check(fl,string,fl,s,CURRENT_JIZUME);
  684.                 /* 左側と string を接続してカットする */
  685.  
  686.     if (*s) {    /* １行ではおさまらなかった（string は２行以上にまたがる） */
  687.         *bx = etc_bit_convert_and_disp(*bx,CWY0+*by,&fl[fl_len]);
  688. #if 0
  689.         *bx = disp_half_line(x,CWY0+y,s);
  690.         *bx = disp_half_line_rel(*bx,*by,&fl[fl_len]);    /* まずは１行表示 */
  691. #endif
  692.         while(*s) {
  693.             if (++(*by) > ly) {    /* ウインドウからはみ出る */
  694.                 register UNIT *uuu;
  695.  
  696.                 scroll_up_counter++;
  697.                 if (CY) {
  698.                     uuu = disp_scroll_up1();
  699.                     SCREEN[CWY1] = uuu->ATO;
  700.                     (*by)--;    /* 戻す */
  701.                     CY--;
  702.                 } else {
  703.                     return(scroll_up_counter);
  704.                 }
  705.             }
  706.             cut_line(s,l,s,CURRENT_JIZUME);
  707. /*etc_beep();*/
  708.             *bx = etc_bit_convert_and_disp(0,CWY0+*by,l);
  709. /*            *bx = disp_half_line_rel(0,*by,l);*/
  710.         }
  711.         strcpy(fl,l);    /* 最後に表示した物を fl とする */
  712.         if (etc_last(fl) == CR) {    /* 最後に表示した行が改行で終わっている */
  713.             (*by)++;        /* 次に表示を開始するのは、もう一行先 */
  714.             *bx = 0;        /* の行頭から */
  715.             *fl = EOS;
  716.         }
  717.         return(scroll_up_counter);
  718.     } else {    /* １行でおさまった */
  719.         *bx = disp_half_line_rel(*bx,*by,&fl[fl_len]);
  720.         if (etc_last(string) == CR) {
  721.             (*by)++;
  722.             *bx = 0;
  723.             *fl = EOS;
  724.         }
  725.         return(0);
  726.     }
  727. }
  728.  
  729. UWORD CRX,CRY;
  730. UWORD FCR;
  731.  
  732. /* 指定された行のバイト位置を x,y として、それ以降の画面を書き直す */
  733. /* 見える範囲内だけ、超特急で書く */
  734. /* もちろんカレントウインドウだけ */
  735. /* 多少いい加減でも速度の方を優先 */
  736. /* TEXT に反映しない */
  737. /* あとでエコーするでしょ */
  738. /* TBUFF_R が最初にある */
  739. /* 改行で節約できたらする */
  740. void
  741. disp_trans_half_flush(UNIT *p0,int bp,int x,int y)/* ,,, */
  742. { 
  743.     UBYTE l[VERY_LONG_LINE*8], s[VERY_LONG_LINE*8];
  744.     register UNIT *p;
  745.     register int flag;
  746.     register UWORD c;
  747.     int y0;
  748.  
  749.     FCR = 1;
  750.     p = p0;
  751.     *l = EOS;
  752.     CUT_GETA = x;        /* フラッシュの開始点 */
  753.     y0 = y;
  754.  
  755.     while(SCREEN[CWY0+y0] != p) {
  756.         y0--;
  757.         if ((y0 < 0) || (CWY0+y0 < 0)) {
  758.             y0 = y;
  759.             while(SCREEN[CWY0+y0] != p) {
  760.                 y0++;
  761.             }
  762.             break;
  763.         }
  764.     }
  765.  
  766.     for(;y0 <= y;y0++) {
  767.         if (p == TAIL) {
  768.             break;
  769.         }
  770.         line_cat_body(l,p);
  771.         p = p->ATO;
  772.     }
  773.  
  774.     if (p != TAIL) {
  775.         line_cat_body(l,p);
  776.     }
  777. /*under_print(l);binkey();*/
  778. /*    p = p0;*/
  779.  
  780.     if (x >= CURRENT_JIZUME) {
  781.         if (l[bp] != CR) {
  782.             x = 0;
  783.             if (++y > (CWY1-CWY0)) {    /* いきなり画面外である */
  784.                 CUT_GETA = 0;
  785.                 return;
  786.             }
  787.         }
  788.     }
  789.  
  790.     flag = cut_line(&l[bp],s,l,CURRENT_JIZUME-x);    /* 最初の半行 */
  791.     if (((c = etc_last(s)) == CR) || flag) {    /* 余りがある＝完全に一行が取れた */
  792. /*        disp_1line_rel_trans0(x,y,s);*/
  793. /*        CUT_GETA = 0;*/
  794.         if (c == CR) {    /* !!!改行を書こうとしている */
  795.             if (CRX) {    /* 既に書いた */
  796.                 if (CRY == y) {    /* 前回と同じ行に改行を書く */
  797.                     disp_1line_rel_trans0(x,y,s);
  798.                     CUT_GETA = 0;
  799.                     return;
  800.                 } else {    /* 最初の改行が移動した？ */
  801.                     if (FCR) {
  802.                         if (!x && (y == CRY+1)) {
  803.                     /* x が非零ならば、未変換を左に持つ行かも知れない */
  804.                             disp_trans_scroll_dn1(y);
  805.                             disp_1line_rel_trans0(x,y,s);
  806.                             CRY = y;
  807.                             return;
  808.                         }
  809.                         CRY = y;    /* 続行 */
  810.                     }
  811.                 }
  812.             } else {        /* まだ書いてない */
  813.                 CRX = 1;
  814.                 CRY = y;
  815.             }
  816.             FCR = 0;
  817.         }
  818.         disp_1line_rel_trans0(x,y,s);
  819.         CUT_GETA = 0;
  820. #if 0
  821.         if (!flag && (c == CR)) {
  822. window0();printf("[%d][%d]",y0,y);
  823.             return;
  824.         }
  825. #endif
  826.         if (p != TAIL) {
  827.             p = p->ATO;
  828.         }
  829. #if 0
  830.         if (p == TAIL) {    /* 末行だ,,,, */
  831.             line_append1(p = line_get_free());
  832.         } else {
  833.             p = p->ATO;
  834.         }
  835.         /* これ以降、p の先頭に l を挿入すれば良い */
  836. #endif
  837.     } else {
  838.         strcpy(l,s);    /* 戻す */
  839.         p = p->ATO;
  840.         if ((p == TAIL) || (!p)) {    /* もう後の行は無い */
  841.             disp_1line_rel_trans0(x,y,l);
  842.             CUT_GETA = 0;
  843.             /* ウインドウ最下行までを消して終了 */
  844.             for(y++;y <= (CWY1-CWY0);y++) {
  845.                 disp_half_line_rel(0,y,(STR) "");
  846.             }
  847.             return;
  848.         }
  849.         line_cat_body(l,p);    /* 次の行を追加する */
  850. #if 0
  851.         flag = cut_line(&l[bp],s,l,CURRENT_JIZUME-x);    /* 最初の半行 */
  852. #else
  853.         flag = cut_line(l,s,l,CURRENT_JIZUME-x);    /* 最初の半行 */
  854. #endif                        /* flag = strlrn(l) */
  855.         if (((c = etc_last(s)) == CR) || flag) {
  856.                 /* 余りがある＝完全に一行が取れた */
  857. /*            disp_1line_rel_trans0(x,y,s);*/
  858. /*            CUT_GETA = 0;*/
  859.             if (c == CR) {    /* !!!改行を書こうとしている */
  860.                 if (CRX | CRY) {    /* 既に書いた */
  861.                     if (CRY == y) {    /* 前回と同じ行に改行を書く */
  862.                         disp_1line_rel_trans0(x,y,s);
  863.                         CUT_GETA = 0;
  864.                         return;
  865.                     } else {
  866.                         if (FCR) {
  867.                             if (y == CRY+1) {
  868.                                 disp_trans_scroll_dn1(y);
  869.                                 disp_1line_rel_trans0(x,y,s);
  870.                                 CRY = y;
  871.                                 return;
  872.                             }
  873.                             CRY = y;    /* 続行 */
  874.                         }
  875.                     }
  876.                 } else {        /* まだ書いてない */
  877.                     CRX = 1;
  878.                     CRY = y;
  879.                 }
  880.                 FCR = 0;
  881.             }
  882.             disp_1line_rel_trans0(x,y,s);
  883.             CUT_GETA = 0;
  884. #if 0
  885.             if (flag == i) {
  886. etc_beep();etc_beep();
  887.                 return;
  888.             }
  889. #endif
  890.             p = p->ATO;
  891.             /* これ以降、p の先頭に l を挿入すれば良い */
  892.         } else {
  893.             /* 出入りが無かったのだから、これで終わり */
  894.             disp_1line_rel_trans0(x,y,s);
  895. #if 1
  896.             CUT_GETA = 0;
  897.             return;
  898. #endif
  899.         }
  900.     }
  901.     CUT_GETA = 0;    /* ダメ押し */
  902.     y++;
  903.     disp_line_wave(p,y,l);
  904. }
  905.  
  906. UBYTE ccc = 15;
  907.  
  908. /* up の指す行（位置は y）の行頭に s を挿入し、次々に送って行く */
  909. /* エコーしない */
  910. /* テキストに反映しない */
  911. /* 改行で節約できたらする */
  912. void
  913. disp_line_wave(UNIT *up,int y,STR s)
  914. {
  915.     UBYTE l[VERY_LONG_LINE*8],t[VERY_LONG_LINE*8];
  916.     register UNIT *wp = up;
  917.     register int i;
  918.     register int ly;
  919.  
  920.     if (y > (ly = (CWY1-CWY0))) {
  921.         return;
  922.     }
  923.  
  924. /*
  925. window0();
  926. printf("[%s][%s]",s,up->BODY);binkey();
  927. */
  928. /*etc_color(ccc);if (ccc == 15) ccc = 14; else ccc = 15;*/
  929.     strcpy(l,s);
  930.     if (wp != TAIL) {
  931.         line_cat_body(l,wp);
  932.     }
  933.     while(y <= ly) {
  934. /* s1 -> s2（切り出し）+ s3（余り）s1 == s3 でもＯＫ */
  935.         if (cut_line(l,t,l,CURRENT_JIZUME)) {    /* 余りの長さを返す */
  936. /*            etc_bit_convert_and_disp(0,CWY0+y,t);*/
  937.             if (etc_last(t) == CR) {    /* !!!改行を書こうとしている */
  938.                 if (CRX | CRY) {    /* 既に書いた */
  939.                     if (CRY == y) {    /* 前回と同じ行に改行を書く */
  940.                         etc_bit_convert_and_disp(0,CWY0+y,t);
  941.                         return;
  942.                     } else {
  943.                         if (FCR) {
  944.                             if (y == CRY+1) {
  945.                                 disp_trans_scroll_dn1(y);
  946.                                 etc_bit_convert_and_disp(0,CWY0+y,t);
  947.                                 CRY = y;
  948.                                 return;
  949.                             }
  950.                             CRY = y;    /* 続行 */
  951.                         }
  952.                     }
  953.                 } else {        /* まだ書いてない */
  954.                     CRX = 1;
  955.                     CRY = y;
  956.                 }
  957.                 FCR = 0;
  958.             }
  959.             etc_bit_convert_and_disp(0,CWY0+y,t);
  960.             if (wp != TAIL) {
  961.                 wp = wp->ATO;
  962.                 line_cat_body(l,wp);
  963.             }
  964.         } else {            /* 余りが無い */
  965. /*            etc_bit_convert_and_disp(0,CWY0+y,t);*/
  966.             if (etc_last(t) == CR) {    /* !!!改行を書こうとしている */
  967.                 if (CRX | CRY) {    /* 既に書いた */
  968.                     if (CRY == y) {    /* 前回と同じ行に改行を書く */
  969.                         etc_bit_convert_and_disp(0,CWY0+y,t);
  970.                         return;
  971.                     } else {
  972.                         if (FCR) {
  973.                             if (y == CRY+1) {
  974.                                 disp_trans_scroll_dn1(y);
  975.                                 etc_bit_convert_and_disp(0,CWY0+y,t);
  976.                                 CRY = y;
  977.                                 return;
  978.                             }
  979.                             CRY = y;    /* 続行 */
  980.                         }
  981.                     }
  982.                 } else {        /* まだ書いてない */
  983.                     CRX = 1;
  984.                     CRY = y;
  985.                 }
  986.                 FCR = 0;
  987.             }
  988.             etc_bit_convert_and_disp(0,CWY0+y,t);
  989.             wp = wp->ATO;
  990.             if ((!wp) || (wp == TAIL)) {
  991.                     /* ウインドウ最下行までを消して終了 */
  992.                 for(++y;y <= (CWY1-CWY0);y++) {
  993.                     etc_bit_convert_and_disp(0,CWY0+y,(STR)"");
  994.                 }
  995.                 break;            /* 終了 */
  996.             } else {
  997.                 line_cat_body(l,wp);
  998.             }
  999.         }
  1000.         y++;
  1001.     }
  1002. /*error("5");*/
  1003.  
  1004. }
  1005.  
  1006. /* y 行から下を n 行スクロールダウンする */
  1007. /* y は相対 */
  1008. void
  1009. disp_trans_scroll_dn1(int y)
  1010. {
  1011.     register int lyw_total,yw;
  1012.     register int wy0,wy1;
  1013.  
  1014.     UBYTE w[MAXLINE];
  1015.  
  1016. /*sprintf(w,"(%d)(%d)",y,n);under_print(w);binkey();*/
  1017.     lyw_total = LYW_TOTAL/4;
  1018.     wy0 = CWY0 + y;
  1019.     wy1 = CWY1;
  1020.     if (yw = lyw_total*(wy1-wy0)) {    /* スクロールするラスタユニット数 */
  1021. /*        TXRASCPY(((wy1-n+1)*lyw_total-1)*256 + (wy1+1)*lyw_total-1,yw,0x8003);*/
  1022.         TXRASCPY((wy1*lyw_total-1)*256+(wy1+1)*lyw_total-1,yw,0x8003);
  1023.     }
  1024. }
  1025.  
  1026.  
  1027. void
  1028. disp_trim_tail()
  1029. {
  1030.     register int i;
  1031.  
  1032.     i = 0;
  1033.     while(1) {
  1034.         if (i == YWIDTH0) {    /* 絶対的最後 */
  1035.             return;
  1036.         }
  1037.         if (SCREEN[i] == TAIL) {
  1038.             i++;
  1039.             while(SCREEN[i] == TAIL) {
  1040.                 SCREEN[i++] = NULL;
  1041.                 if (i == YWIDTH0) {    /* 絶対的最後 */
  1042.                     return;
  1043.                 }
  1044.             }
  1045.         } else {
  1046.             i++;
  1047.         }
  1048.     }
  1049. }
  1050.